{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:06:40.397013Z",
     "start_time": "2025-01-23T14:06:28.203564Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:36:53.595641Z",
     "iopub.status.busy": "2025-01-23T14:36:53.595477Z",
     "iopub.status.idle": "2025-01-23T14:36:58.819763Z",
     "shell.execute_reply": "2025-01-23T14:36:58.819103Z",
     "shell.execute_reply.started": "2025-01-23T14:36:53.595621Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:06:45.324113Z",
     "start_time": "2025-01-23T14:06:40.398015Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:36:58.821328Z",
     "iopub.status.busy": "2025-01-23T14:36:58.821016Z",
     "iopub.status.idle": "2025-01-23T14:37:26.166648Z",
     "shell.execute_reply": "2025-01-23T14:37:26.166039Z",
     "shell.execute_reply.started": "2025-01-23T14:36:58.821305Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://mirrors.cloud.aliyuncs.com/pypi/simple\n",
      "Collecting tensorflow\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/d4/80/1567ccc375ccda4d28af28c960cca7f709f7c259463ac1436554697e8868/tensorflow-2.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (615.3 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m615.3/615.3 MB\u001b[0m \u001b[31m3.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.1.0)\n",
      "Collecting astunparse>=1.6.0 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/2b/03/13dde6512ad7b4557eb792fbcf0c653af6076b81e5941d36ec61f7ce6028/astunparse-1.6.3-py2.py3-none-any.whl (12 kB)\n",
      "Collecting flatbuffers>=24.3.25 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/55/75/ed93520bceceabd78305717b3500224625f92e03617ba1f8e08d60e8eefb/flatbuffers-25.1.21-py2.py3-none-any.whl (30 kB)\n",
      "Collecting gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/a3/61/8001b38461d751cd1a0c3a6ae84346796a5758123f3ed97a1b121dfbf4f3/gast-0.6.0-py3-none-any.whl (21 kB)\n",
      "Collecting google-pasta>=0.1.1 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/a3/de/c648ef6835192e6e2cc03f40b19eeda4382c49b5bafb43d88b931c4c74ac/google_pasta-0.2.0-py3-none-any.whl (57 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.5/57.5 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hCollecting libclang>=13.0.0 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/1d/fc/716c1e62e512ef1c160e7984a73a5fc7df45166f2ff3f254e71c58076f7c/libclang-18.1.1-py2.py3-none-manylinux2010_x86_64.whl (24.5 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.5/24.5 MB\u001b[0m \u001b[31m91.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hCollecting opt-einsum>=2.3.2 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl (71 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.9/71.9 kB\u001b[0m \u001b[31m20.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: packaging in /usr/local/lib/python3.10/site-packages (from tensorflow) (24.2)\n",
      "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/site-packages (from tensorflow) (5.29.2)\n",
      "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.32.3)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/site-packages (from tensorflow) (69.5.1)\n",
      "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.17.0)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.5.0)\n",
      "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/site-packages (from tensorflow) (4.12.2)\n",
      "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.17.0)\n",
      "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.69.0)\n",
      "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.10/site-packages (from tensorflow) (2.18.0)\n",
      "Collecting keras>=3.5.0 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/fe/cf/aea9087c4d7fafe956a0cc0ff6c3327d10fb8442cda50f992a2186921fa0/keras-3.8.0-py3-none-any.whl (1.3 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m118.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: numpy<2.1.0,>=1.26.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (1.26.4)\n",
      "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.10/site-packages (from tensorflow) (3.12.1)\n",
      "Collecting ml-dtypes<0.5.0,>=0.4.0 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/16/86/a9f7569e7e4f5395f927de38a13b92efa73f809285d04f2923b291783dd2/ml_dtypes-0.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m127.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hCollecting tensorflow-io-gcs-filesystem>=0.23.1 (from tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/f3/48/47b7d25572961a48b1de3729b7a11e835b888e41e0203cca82df95d23b91/tensorflow_io_gcs_filesystem-0.37.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (5.1 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.1/5.1 MB\u001b[0m \u001b[31m101.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/site-packages (from astunparse>=1.6.0->tensorflow) (0.44.0)\n",
      "Requirement already satisfied: rich in /usr/local/lib/python3.10/site-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
      "Collecting namex (from keras>=3.5.0->tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/73/59/7854fbfb59f8ae35483ce93493708be5942ebb6328cd85b3a609df629736/namex-0.0.8-py3-none-any.whl (5.8 kB)\n",
      "Collecting optree (from keras>=3.5.0->tensorflow)\n",
      "  Downloading https://mirrors.cloud.aliyuncs.com/pypi/packages/09/89/b0cbfadc5006028a7be33f5e20527228f169576100ae58c1c54ca9268f43/optree-0.14.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (391 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m391.8/391.8 kB\u001b[0m \u001b[31m70.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/site-packages (from requests<3,>=2.21.0->tensorflow) (2024.12.14)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
      "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
      "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/site-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
      "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/site-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (2.1.5)\n",
      "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/site-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
      "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/site-packages (from rich->keras>=3.5.0->tensorflow) (2.19.0)\n",
      "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
      "Installing collected packages: namex, libclang, flatbuffers, tensorflow-io-gcs-filesystem, optree, opt-einsum, ml-dtypes, google-pasta, gast, astunparse, keras, tensorflow\n",
      "Successfully installed astunparse-1.6.3 flatbuffers-25.1.21 gast-0.6.0 google-pasta-0.2.0 keras-3.8.0 libclang-18.1.1 ml-dtypes-0.4.1 namex-0.0.8 opt-einsum-3.4.0 optree-0.14.0 tensorflow-2.18.0 tensorflow-io-gcs-filesystem-0.37.1\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.3.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:01.487583Z",
     "start_time": "2025-01-23T14:06:45.325113Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:37:26.167522Z",
     "iopub.status.busy": "2025-01-23T14:37:26.167331Z",
     "iopub.status.idle": "2025-01-23T14:46:11.060342Z",
     "shell.execute_reply": "2025-01-23T14:46:11.059787Z",
     "shell.execute_reply.started": "2025-01-23T14:37:26.167500Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-23 22:37:26.416130: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2025-01-23 22:37:26.428198: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "E0000 00:00:1737643046.442938     473 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "E0000 00:00:1737643046.447457     473 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2025-01-23 22:37:26.462744: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz\n",
      "\u001b[1m17464789/17464789\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m515s\u001b[0m 30us/step\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:01.492304Z",
     "start_time": "2025-01-23T14:07:01.488605Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:11.061883Z",
     "iopub.status.busy": "2025-01-23T14:46:11.061488Z",
     "iopub.status.idle": "2025-01-23T14:46:11.065144Z",
     "shell.execute_reply": "2025-01-23T14:46:11.064660Z",
     "shell.execute_reply.started": "2025-01-23T14:46:11.061860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train (25000,) (25000,)\n",
      "test (25000,) (25000,)\n"
     ]
    }
   ],
   "source": [
    "print(\"train\", train_data.shape, train_labels.shape)\n",
    "print(\"test\", test_data.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:01.559067Z",
     "start_time": "2025-01-23T14:07:01.493309Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:11.066114Z",
     "iopub.status.busy": "2025-01-23T14:46:11.065677Z",
     "iopub.status.idle": "2025-01-23T14:46:15.983161Z",
     "shell.execute_reply": "2025-01-23T14:46:15.982639Z",
     "shell.execute_reply.started": "2025-01-23T14:46:11.066094Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json\n",
      "\u001b[1m1641221/1641221\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 2us/step\n",
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:01.596240Z",
     "start_time": "2025-01-23T14:07:01.560071Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:15.983953Z",
     "iopub.status.busy": "2025-01-23T14:46:15.983757Z",
     "iopub.status.idle": "2025-01-23T14:46:16.012429Z",
     "shell.execute_reply": "2025-01-23T14:46:16.011923Z",
     "shell.execute_reply.started": "2025-01-23T14:46:15.983933Z"
    }
   },
   "outputs": [],
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:02.660285Z",
     "start_time": "2025-01-23T14:07:01.597701Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:16.014763Z",
     "iopub.status.busy": "2025-01-23T14:46:16.014354Z",
     "iopub.status.idle": "2025-01-23T14:46:17.028558Z",
     "shell.execute_reply": "2025-01-23T14:46:17.027912Z",
     "shell.execute_reply.started": "2025-01-23T14:46:16.014742Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:02.683283Z",
     "start_time": "2025-01-23T14:07:02.661297Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:17.029488Z",
     "iopub.status.busy": "2025-01-23T14:46:17.029236Z",
     "iopub.status.idle": "2025-01-23T14:46:17.064842Z",
     "shell.execute_reply": "2025-01-23T14:46:17.064277Z",
     "shell.execute_reply.started": "2025-01-23T14:46:17.029466Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx] #直接切片取前max_length-2个单词，然后加上bos和eos\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:02.688477Z",
     "start_time": "2025-01-23T14:07:02.684290Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:17.065989Z",
     "iopub.status.busy": "2025-01-23T14:46:17.065494Z",
     "iopub.status.idle": "2025-01-23T14:46:17.070375Z",
     "shell.execute_reply": "2025-01-23T14:46:17.069746Z",
     "shell.execute_reply.started": "2025-01-23T14:46:17.065957Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:04.589480Z",
     "start_time": "2025-01-23T14:07:02.689479Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:17.071486Z",
     "iopub.status.busy": "2025-01-23T14:46:17.071111Z",
     "iopub.status.idle": "2025-01-23T14:46:20.423412Z",
     "shell.execute_reply": "2025-01-23T14:46:20.422859Z",
     "shell.execute_reply.started": "2025-01-23T14:46:17.071455Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:04.596580Z",
     "start_time": "2025-01-23T14:07:04.590485Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.424211Z",
     "iopub.status.busy": "2025-01-23T14:46:20.424031Z",
     "iopub.status.idle": "2025-01-23T14:46:20.427485Z",
     "shell.execute_reply": "2025-01-23T14:46:20.427006Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.424191Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:07:04.622777Z",
     "start_time": "2025-01-23T14:07:04.598585Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.428237Z",
     "iopub.status.busy": "2025-01-23T14:46:20.428007Z",
     "iopub.status.idle": "2025-01-23T14:46:20.469006Z",
     "shell.execute_reply": "2025-01-23T14:46:20.468476Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.428218Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "source": [
    "for text, label in train_dl:\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.219113Z",
     "start_time": "2025-01-23T14:30:40.210864Z"
    },
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.469749Z",
     "iopub.status.busy": "2025-01-23T14:46:20.469579Z",
     "iopub.status.idle": "2025-01-23T14:46:20.478570Z",
     "shell.execute_reply": "2025-01-23T14:46:20.478125Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.469730Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(RNN, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)    # (10000,16)\n",
    "        self.rnn = nn.RNN(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)  # batch_first在最前面，所以batch_size=True  \n",
    "        # Xt-1*W(1,64)*(64,64)+Xt*U(1,16)*(16,64)  循环了500次  循环不断地把每个词代进去        \n",
    "        # bidirectional=False代表单层单向  bidirectional是双向的意思\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim) #全连接层对接最后一个时间步的输出  单向时是(64×64)  双向时是单向的输出和双向的输出结合起来，即输入为(500,64)和(500,64) ->(500,128)，所以这里是(128,64)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)   # (64×1)\n",
    "         \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, final_hidden = self.rnn(x)\n",
    "        # print(f'seq_output.shape={seq_output.shape}')   # 每个时间步都是(500,64)\n",
    "        # print(f'final_hidden.shape={final_hidden.shape}')   # final_hidden是RNN的最后一个时间步的隐藏状态\n",
    "        # [bs, seq length, hidden_dim], [*, bs, hidden_dim]\n",
    "        x = seq_output[:, -1, :]  #通过seq_output[:,-1,:]，从 (128,500,64) 的张量中提取了每个序列的最后一个时间步的隐藏状态，结果是一个形状为 (128, 64) 的张量\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 RNN \"))       \n",
    "for key, value in RNN().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ih就是U(16×64)，hh就是W(64×64)   行乘列就要加一个偏置，因为W和U都是64列，所以偏置都为64  偏置=hidden_dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.340629Z",
     "start_time": "2025-01-23T14:30:40.299903Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.479391Z",
     "iopub.status.busy": "2025-01-23T14:46:20.479068Z",
     "iopub.status.idle": "2025-01-23T14:46:20.563512Z",
     "shell.execute_reply": "2025-01-23T14:46:20.563059Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.479359Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 1])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#做前向计算，看下输出的shape\n",
    "model = RNN()  \n",
    "sample_inputs = torch.randint(0, vocab_size, (128, 500))\n",
    "model(sample_inputs).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.346982Z",
     "start_time": "2025-01-23T14:30:40.341628Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.564238Z",
     "iopub.status.busy": "2025-01-23T14:46:20.564061Z",
     "iopub.status.idle": "2025-01-23T14:46:20.567573Z",
     "shell.execute_reply": "2025-01-23T14:46:20.567067Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.564218Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.351377Z",
     "start_time": "2025-01-23T14:30:40.347981Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:59:25.799022Z",
     "iopub.status.busy": "2025-01-23T14:59:25.798668Z",
     "iopub.status.idle": "2025-01-23T14:59:25.804522Z",
     "shell.execute_reply": "2025-01-23T14:59:25.804058Z",
     "shell.execute_reply.started": "2025-01-23T14:59:25.798999Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 一层双向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "        rnn.weight_ih_l0_reverse        paramerters num: 1024\n",
      "        rnn.weight_hh_l0_reverse        paramerters num: 4096\n",
      "         rnn.bias_ih_l0_reverse         paramerters num: 64\n",
      "         rnn.bias_hh_l0_reverse         paramerters num: 64\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 RNN \"))       \n",
    "for key, value in RNN(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.351377Z",
     "start_time": "2025-01-23T14:30:40.347981Z"
    },
    "ExecutionIndicator": {
     "show": false
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:59:27.855847Z",
     "iopub.status.busy": "2025-01-23T14:59:27.855491Z",
     "iopub.status.idle": "2025-01-23T14:59:27.861349Z",
     "shell.execute_reply": "2025-01-23T14:59:27.860881Z",
     "shell.execute_reply.started": "2025-01-23T14:59:27.855823Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 俩层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "            rnn.weight_ih_l1            paramerters num: 4096\n",
      "            rnn.weight_hh_l1            paramerters num: 4096\n",
      "             rnn.bias_ih_l1             paramerters num: 64\n",
      "             rnn.bias_hh_l1             paramerters num: 64\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:=^80}\".format(\" 两层单向 RNN \"))       # l1 in是64  设的hidden_dim=64  双层就是前一层的输入变成了下一层的输出\n",
    "for key, value in RNN(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T15:03:38.287348Z",
     "iopub.status.busy": "2025-01-23T15:03:38.287023Z",
     "iopub.status.idle": "2025-01-23T15:03:38.293543Z",
     "shell.execute_reply": "2025-01-23T15:03:38.293056Z",
     "shell.execute_reply.started": "2025-01-23T15:03:38.287323Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================== 两层单向 RNN ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "            rnn.weight_ih_l0            paramerters num: 1024\n",
      "            rnn.weight_hh_l0            paramerters num: 4096\n",
      "             rnn.bias_ih_l0             paramerters num: 64\n",
      "             rnn.bias_hh_l0             paramerters num: 64\n",
      "        rnn.weight_ih_l0_reverse        paramerters num: 1024\n",
      "        rnn.weight_hh_l0_reverse        paramerters num: 4096\n",
      "         rnn.bias_ih_l0_reverse         paramerters num: 64\n",
      "         rnn.bias_hh_l0_reverse         paramerters num: 64\n",
      "            rnn.weight_ih_l1            paramerters num: 8192\n",
      "            rnn.weight_hh_l1            paramerters num: 4096\n",
      "             rnn.bias_ih_l1             paramerters num: 64\n",
      "             rnn.bias_hh_l1             paramerters num: 64\n",
      "        rnn.weight_ih_l1_reverse        paramerters num: 8192\n",
      "        rnn.weight_hh_l1_reverse        paramerters num: 4096\n",
      "         rnn.bias_ih_l1_reverse         paramerters num: 64\n",
      "         rnn.bias_hh_l1_reverse         paramerters num: 64\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:=^80}\".format(\" 两层单向 RNN \"))\n",
    "for key, value in RNN(num_layers=2,bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.374119Z",
     "start_time": "2025-01-23T14:30:40.369331Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.571418Z",
     "iopub.status.busy": "2025-01-23T14:46:20.571211Z",
     "iopub.status.idle": "2025-01-23T14:46:20.671776Z",
     "shell.execute_reply": "2025-01-23T14:46:20.671341Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.571400Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.923210Z",
     "start_time": "2025-01-23T14:30:40.389080Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.672670Z",
     "iopub.status.busy": "2025-01-23T14:46:20.672292Z",
     "iopub.status.idle": "2025-01-23T14:46:20.815790Z",
     "shell.execute_reply": "2025-01-23T14:46:20.815346Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.672650Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.928952Z",
     "start_time": "2025-01-23T14:30:40.924213Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.816503Z",
     "iopub.status.busy": "2025-01-23T14:46:20.816321Z",
     "iopub.status.idle": "2025-01-23T14:46:20.821296Z",
     "shell.execute_reply": "2025-01-23T14:46:20.820837Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.816484Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-23T14:30:40.933586Z",
     "start_time": "2025-01-23T14:30:40.929958Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T14:46:20.822195Z",
     "iopub.status.busy": "2025-01-23T14:46:20.821816Z",
     "iopub.status.idle": "2025-01-23T14:46:20.825996Z",
     "shell.execute_reply": "2025-01-23T14:46:20.825541Z",
     "shell.execute_reply.started": "2025-01-23T14:46:20.822175Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2025-01-23T14:30:40.934587Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T15:06:07.700396Z",
     "iopub.status.busy": "2025-01-23T15:06:07.699964Z",
     "iopub.status.idle": "2025-01-23T15:08:33.330742Z",
     "shell.execute_reply": "2025-01-23T15:08:33.330232Z",
     "shell.execute_reply.started": "2025-01-23T15:06:07.700365Z"
    },
    "jupyter": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 85%|████████▌ | 3332/3920 [02:25<00:25, 22.88it/s, epoch=16]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 17 / global_step 3332\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "# model = RNN(bidirectional=True) #双向单层\n",
    "# model = RNN()  # 单向单层\n",
    "model = RNN(num_layers=2)  #双层双向\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-rnn\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-rnn\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T15:10:44.855000Z",
     "iopub.status.busy": "2025-01-23T15:10:44.854638Z",
     "iopub.status.idle": "2025-01-23T15:10:45.072737Z",
     "shell.execute_reply": "2025-01-23T15:10:45.072265Z",
     "shell.execute_reply.started": "2025-01-23T15:10:44.854974Z"
    },
    "jupyter": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T15:10:48.273957Z",
     "iopub.status.busy": "2025-01-23T15:10:48.273604Z",
     "iopub.status.idle": "2025-01-23T15:10:51.930569Z",
     "shell.execute_reply": "2025-01-23T15:10:51.930083Z",
     "shell.execute_reply.started": "2025-01-23T15:10:48.273933Z"
    },
    "jupyter": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.5642\n",
      "accuracy: 0.7270\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-rnn/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30616,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
